package com.rede.didiok.rank.service;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.rede.didiok.common.dto.BusinessIdListDto;
import com.rede.didiok.common.dto.BusinessObjectListDto;
import com.rede.didiok.common.dto.rank.RankMemberDto;
import com.rede.didiok.common.dto.user.GeneralEditDto;
import com.rede.didiok.common.utils.PageUtils;
import com.rede.didiok.rank.entity.RankMemberEntity;
import com.rede.didiok.rank.vo.RankMemberDetailVo;
import com.rede.didiok.rank.vo.RankMemberSaveVo;

/**
 * 榜单成员
 *
 * @author Rede
 * @email didiok@foxmail.com
 * @date 2023-07-20 22:09:24
 */
public interface RankMemberService extends IService<RankMemberEntity> {

    /***************************** admin:start **************************/
    // region  didiok-admin

    /**
     * 获取状态 status=1 的榜单成员的总数量
     */
    Integer getRankMemberCount();

    /**
     * 获取每个rank榜单下的榜单成员数目
     */
    List<Map<String, Object>> getRankMemberCountByRank();

    /**
     * 获取一年内发布的榜单成员数
     *
     * @return
     */
    Map<String, Object> getRankMemberContributeCount();

    /**
     * 获取博客列表
     *
     * @param rankMemberVO
     * @return
     */
    IPage<RankMemberEntity> getPageListWithGradeAndRankAndTag(RankMemberDto rankMemberVO);

    /**
     * 按照推荐等级查询榜单成员数量
     * @param level
     * @return
     */
    Integer countRankMemberByLevel(Integer level);

    /**
     * 管理员保存、并发布新增领域事件
     * @param rankMemberDto
     * @return
     */
    Boolean addRankMemberByAdmin(RankMemberDto rankMemberDto);

    /**
     * 本地博客上传
     *
     * @param list
     * @return
     */
    String uploadLocalRankMember(List<RankMemberDto> list) ;

    /**
     * 管理员编辑榜单成员
     * @param rankMemberDto
     * @return
     */
    String editRankMemberByAdmin(RankMemberDto rankMemberDto);

    /**
     * 修改榜单成员等级
     * @param rankMemberDto
     * @return
     */
    String updateRankMemberLevel(RankMemberDto rankMemberDto);

    /**
     * 发布/下架榜单成员
     * @param rankMemberDto
     * @return
     */
    String publishByAdmin(RankMemberDto rankMemberDto);

    /**
     * 推荐博客排序调整
     *
     * @param rankMemberDtoList
     * @return
     */
    String editBatch(List<RankMemberDto> rankMemberDtoList);

    /**
     * 删除榜单成员
     * @param rankMemberDto
     * @return
     */
    String deleteRankMemberByAdmin(RankMemberDto rankMemberDto);

    /**
     * 批量删除榜单成员
     *
     * @param list
     * @return
     */
    String deleteBatchRankMember(List<RankMemberDto> list);

    /**
     * 审核榜单成员
     *
     * @param rankMemberDto
     * @return
     */
    String auditRankMember(RankMemberDto rankMemberDto);

    /**
     * 博客简介刷数
     *
     * @param
     * @return
     */
    String flushRankMemberSummary();

    /**
     * 批量同步榜单成员索引
     * @return
     */
    String buildRankMemberAggDoc();

    /**
     * 通过标签搜索博客
     *
     * @param gradeUid
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> searchRankMemberByGrade(String gradeUid, Long currentPage, Long pageSize);


    /**
     * 删除和博客标签有关的Redis缓存
     */
    void deleteRedisByMemberTag();

    // endregion
    /***************************** admin:end **************************/



    /***************************** web:start **************************/
    // region didiok-web

    /**
     * 获取榜单成员列表(包括榜单成员的图片、用户、成员等级试属性)
     * @param rankMemberDto
     * @return
     */
    IPage<RankMemberEntity> getPageListWithPicAndRank(RankMemberDto rankMemberDto);

    /**
     * 普通用户新增榜单成员
     * @param rankMemberDto
     * @return
     */
    String addRankMemberByUser(RankMemberDto rankMemberDto);

    /**
     * 普通用户编辑博客
     * @param rankMemberDto
     * @return
     */
    String editRankMemberByUser(RankMemberDto rankMemberDto);

    /**
     * 普通用户 发布/下架 博客
     * @param rankMemberDto
     * @return
     */
    String publishByUser(RankMemberDto rankMemberDto);

    /**
     * 普通用户 将活动取消/恢复正常
     * @param rankMemberDto
     * @return
     */
    String changeActivityStatus(RankMemberDto rankMemberDto);

    /**
     * 普通用户 删除博客
     * @param rankMemberDto
     * @return
     */
    String deleteRankMemberByUser(RankMemberDto rankMemberDto);

    /**
     * 随机一文
     *
     * @return
     */
    RankMemberEntity randomRankMember();

    /**
     * 查询博客积分排行榜
     *
     * @return
     */
    List<RankMemberEntity> getLeaderRankMember(Boolean refresh);

    /**
     * 通过推荐等级获取博客Page
     *
     * @param level       推荐级别
     * @param currentPage 当前页
     * @param useSort     是否使用排序字段
     * @return
     */
    IPage<RankMemberEntity> getRankMemberPageByLevel(Integer level, Long currentPage, Integer useSort);

    /**
     * 获取首页排行博客
     *
     * @return
     */
    IPage<RankMemberEntity> getHotRankMember();


    /**
     * 获取最新的博客
     *
     * @param rankMemberVO
     * @return
     */
    IPage<RankMemberEntity> getNewRankMember(RankMemberDto rankMemberVO);

    /**
     * mogu-search调用获取博客的接口[包含内容]
     *
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> getRankMemberBySearch(Long currentPage, Long pageSize);

    /**
     * 按时间戳获取博客
     *
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> getRankMemberByTime(Long currentPage, Long pageSize);

    /**
     * 给博客设置等级、头像、榜单
     *
     * @param rankMember
     * @return
     */
    RankMemberEntity setRankMemberInfoWithGradePicRank(RankMemberEntity rankMember);

    /**
     * 给博客设置等级、头像、榜单
     *
     * @param rankMember
     * @return
     */
    RankMemberEntity setRankMemberInfoWithUser(RankMemberEntity rankMember);

    /**
     * 给博客设置等级、头像、榜单
     *
     * @param rankMember
     * @return
     */
    List<RankMemberEntity> setRankMemberInfoWithPhotoUrl(List<RankMemberEntity> rankMemberList);

    /**
     * 校验访问权限
     * @param rankMember
     * @return
     */
    void checkVisitAuth(RankMemberEntity rankMember);

    /**
     * 通过博客Uid获取点赞数
     *
     * @param uid
     * @return
     */
    Integer getRankMemberPraiseCountByUid(String uid);

    /**
     * 根据标签Uid获取相关的博客
     *
     * @param gradeUid
     * @return
     */
    IPage<RankMemberEntity> getSameRankMemberByGradeUid(String gradeUid);

    /**
     * 根据RankMemberUid获取相关的博客
     *
     * @param rankMemberUid
     * @return
     */
    List<RankMemberEntity> getSameRankMemberByRankMemberUid(String rankMemberUid,String rankUid);

    /**
     * 通过 rankUid 获取榜单列表
     * @param rankUid
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> getListByRankUid(String rankUid, Long currentPage, Long pageSize);

    /**
     * 通过关键字搜索博客列表
     *
     * @param keywords
     * @param currentPage
     * @param pageSize
     * @return
     */
    Map<String, Object> getRankMemberByKeyword(String keywords, Long currentPage, Long pageSize);

    /**
     * 通过榜单搜索成员
     *
     * @param rankUid
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> searchRankMemberByRank(String rankUid, Long currentPage, Long pageSize);

    /**
     * 通过作者搜索博客
     *
     * @param author
     * @param currentPage
     * @param pageSize
     * @return
     */
    IPage<RankMemberEntity> searchRankMemberByUserName(String author, Long currentPage, Long pageSize);

    /**
     * 根据id获取榜单成员
     * @param uid
     * @return
     */
    RankMemberEntity getRankMemberById(String uid);

    /**
     * 榜单成员下架操作
     * @param reportUid
     * @return
     */
    Boolean revocationRankMember(String reportUid);

    /**
     * 获取发表的文章数
     * @param adminUid
     * @param userUid
     * @return
     */
    Integer getRankMemberCountByAdminOrUser(String adminUid, String userUid);

    /**
     * 通过VO获取博客数量
     *
     * @param rankMemberDto
     * @return
     */
    Integer getRankMemberCount(RankMemberDto rankMemberDto);

    // endregion
    /***************************** web:end **************************/


    /**
     * 保存并发布榜单成员
     * @param vo
     */
    void saveAndPublish(RankMemberSaveVo vo) ;

    /**
     * 榜单成员发布
     * @param memberUid
     */
    void memberPublish(String memberUid);

    /**
     * 根据条件查询榜单成员列表
     * @param params
     * @return
     */
    PageUtils queryPageByCondition(Map<String, Object> params);

    /**
     * 查询当前榜单成员的详情
     * @param memberUid
     * @return
     */
    RankMemberDetailVo detail(String memberUid) throws ExecutionException, InterruptedException;


    /**
     * 获取发表的文章数
     *
     * @param userUid
     * @return
     */
    Integer getRankMemberPublishCount(String userUid);

    /**
     * 获取文章被访问数
     *
     * @param userUid
     * @return
     */
    Integer getRankMemberVisitCount(String userUid);


    /**
     * 给博客添加标签、分类、用户信息
     *
     * @return
     */
    List<RankMemberEntity> convertRankMemberInfoList(List<RankMemberEntity> list);

    /**
     * 给博客列表设置分类和标签
     *
     * @param list
     * @return
     */
    List<RankMemberEntity> setGradeAndRankByRankMemberList(List<RankMemberEntity> list);

    /**
     * 给博客列表设置分类，标签，图片
     *
     * @param list
     * @return
     */
    List<RankMemberEntity> setGradeAndRankAndPictureByRankMemberList(List<RankMemberEntity> list);

    /**
     * 给博客设置标签
     *
     * @param rankMember
     * @return
     */
    RankMemberEntity setMemberGradeByRankMember(RankMemberEntity rankMember);

    /**
     * 给博客设置标签、分类和头像
     *
     * @param rankMember
     * @return
     */
    RankMemberEntity setRankMemberInfo(RankMemberEntity rankMember);

    /**
     * 给博客设置分类
     *
     * @param rankMember
     * @return
     */
    RankMemberEntity setCategoryByRankMember(RankMemberEntity rankMember);

    /**
     * 通过推荐等级获取博客列表
     *
     * @param level
     * @return
     */
    List<RankMemberEntity> getRankMemberListByLevel(Integer level);

    /**
     * 通过推荐等级获取博客Page，是否排序
     *
     * @param level
     * @return
     */
    IPage<RankMemberEntity> getRankMemberPageByLevel(Page<RankMemberEntity> page, Integer level, Integer useSort);

    /**
     * 通过状态获取博客数量
     */
    Integer getRankMemberCount(Integer status);

    /**
     * 通过标签获取博客数目
     */
    List<Map<String, Object>> getRankMemberCountByMemberGrade();

    /**
     * 通过标签获取博客数目
     */
    List<Map<String, Object>> getRankMemberCountByCategory();


    /**
     * 通过uid获取博客内容
     *
     * @param uid
     * @return
     */
    RankMemberEntity getRankMemberByUid(String uid);

    /**
     * 获取点击量前top的博客列表
     *
     * @param top
     * @return
     */
    List<RankMemberEntity> getRankMemberListByTop(Integer top);


    /**
     * 批量审批文章
     * @param uidList
     * @param nickname
     * @param auditStatus
     * @param rejectReason
     * @return
     */
    String batchAuditRankMember(List<String> uidList, String nickname, String auditStatus, String rejectReason);


    /**
     * 删除和博客有关的Redis缓存
     */
    void deleteRedisByRankMember();

    //========================mogu-web使用==========================

    /**
     * 通过月份获取日期
     *
     * @param monthDate
     * @return
     */
    String getArticleByMonth(String monthDate);

    /**
     * 修改榜单成员content
     * @param generalEditDto
     * @return
     */
    boolean updateRankMemberContent(GeneralEditDto generalEditDto);

    /**
     * 根据 fileUid 更新对应的所有榜单成员，将其中的fileUid全都更换
     * @param fileUid
     * @return
     */
    boolean updateRankMemberPictureByPictureUid(String fileUid);


    /**
     * 给博客列表设置分类，标签，图片
     *
     * @param list
     * @return
     */
    List<RankMemberEntity> setRankAndGradeAndPictureByRankMemberList(List<RankMemberEntity> list);

    /**
     * 根据Oid列表查询榜单成员
     * @param memberOids
     * @return
     */
    List<RankMemberEntity> listByOids(List<String> memberOids);

    /**
     * 根据各种业务id列表查询对应的对象集合
     * @param businessIdListDto
     * @return
     */
    BusinessObjectListDto listBusinessObjectByIds(BusinessIdListDto businessIdListDto);

    /**
     * 根据用户列表ID  查询各用户发表博客数
     * @return
     */
    List<Map<String, String>> getUsersRankMemberCountByUserIds(List<String> userUids);

    /**
     * 根据用户id和来源统计榜单成员的数量
     * @param userUid
     * @param source
     * @return
     */
    Integer countRankMemberByUserUidAndSource(String userUid, String source);

    /**
     * 根据用户id和文章来源，查询文章的oid和Uid
     * @param userUid
     * @param source
     * @return
     */
    List<RankMemberEntity> listIdByUserUidAndSource(String userUid, String source);

    /**
     * 获取榜单成员列表
     *
     * @param rankMemberDto
     * @return
     */
    public IPage<RankMemberEntity> getPageList(RankMemberDto rankMemberDto);

    IPage<RankMemberEntity>  getRankMemberPageList(RankMemberDto rankMemberDto);

    /**
     * 下载博客
     *
     * @param blogUid
     * @return
     */
    RankMemberEntity downloadRankMember(String memberUid);

    /**
     * 根据标签Uid获取相关的博客
     *
     * @param tagUid
     * @return
     */
    IPage<RankMemberEntity> getSameRankMemberByTagUid(String tagUid);

    /**
     * 给博客列表设置分类和标签
     *
     * @param list
     * @return
     */
    List<RankMemberEntity> setTagAndRankByRankMemberList(List<RankMemberEntity> list);

    /**
     * 获取连续发文的天数
     *
     * @param userUid
     * @return
     */
    Integer getContinuousPublishRankMemberCount(String userUid);


    /**
     * 获取用户所有博客的阅读数
     *
     * @param userUid
     * @return
     */
    Integer getRankMemberClickCount(String userUid);

    /**
     * 根据 uid/oid 查询 RankMemberEntity
     * @param uid
     * @param oid
     * @return
     */
    RankMemberEntity getWithAttrInfoById(String uid, Integer oid);

    /**
     * 根据 uid/oid 查询 RankMemberEntity
     * @param uid
     * @param oid
     * @return
     */
    RankMemberEntity getRankMemberDetailInfoById(String uid, Integer oid);

    /**
     * 根据 条件 查询 RankMemberUid
     * @param rankMemberDto
     * @return
     */
    List<RankMemberDto> listRankMemberUid(RankMemberDto rankMemberDto);
}

